Тема 7. Механизмы управления виртуальной и динамически распределяемой памятью

План лекции

1. Понятие динамически подключаемой библиотеки

2. Структура DLL-библиотеки

3. Создание DLL-библиотеки

4. Проецирование файлов на виртуальное адресное пространство

5. Разработка и использование динамически загружаемых модулей

6. Обмен данными между процессами с использованием динамически загружаемых модулей и разделяемых сегментов памяти

7. Создание многозадачных комплексов

8. Перехват системных вызовов (hooking)

1. Динамически подключаемые библиотеки

1.1. Понятие DLL

DLL (Dynamic Link Library) — библиотека, загружаемая во время выполнения.

1.2. Типы связывания

Неявное (Implicit) связывание:

// При компиляции линкуется .lib файл
#pragma comment(lib, "mylib.lib")

// Использование функций
void MyFunction();  // Объявление
MyFunction();       // Вызов

Явное (Explicit) связывание:

// Загрузка во время выполнения
HMODULE hModule = LoadLibrary(L"mylib.dll");
FARPROC proc = GetProcAddress(hModule, "MyFunction");
((void(*)())proc)();
FreeLibrary(hModule);

2. Структура DLL

2.1. Экспорт функций

// mylib.h
#ifdef MYLIB_EXPORTS
#define MYLIB_API __declspec(dllexport)
#else
#define MYLIB_API __declspec(dllimport)
#endif

// Объявление функции
MYLIB_API int Add(int a, int b);
MYLIB_API void ProcessData(const char* data);

// Экспорт класса
class MYLIB_API MyClass {
public:
    void DoSomething();
};

2.2. Файл определения модуля (.def)

; mylib.def
LIBRARY MYLIB
EXPORTS
    Add         @1
    Subtract    @2
    ProcessData @3 NONAME
    
    ; Экспорт по порядковому номеру
    Multiply    @4
    
    ; Экспорт с псевдонимом
    Div = Divide @5

Преимущества .def файла:

• Экспорт по порядковому номеру (быстрее)
• Скрытие имен функций (NONAME)
• Псевдонимы функций

3. Создание DLL

3.1. Точка входа DLL

// dllmain.cpp
#include <windows.h>

BOOL APIENTRY DllMain(
    HMODULE hModule,
    DWORD  ul_reason_for_call,
    LPVOID lpReserved
) {
    switch (ul_reason_for_call) {
        case DLL_PROCESS_ATTACH:
            // Процесс загрузил DLL
            // Инициализация
            break;
            
        case DLL_THREAD_ATTACH:
            // Создан новый поток
            break;

        case DLL_THREAD_DETACH:
            // Поток завершился
            break;
            
        case DLL_PROCESS_DETACH:
            // Процесс выгружает DLL
            // Освобождение ресурсов
            break;
    }
    return TRUE;
}

3.2. Полный пример DLL

// mathlib.h
#ifdef MATHLIB_EXPORTS
#define MATHLIB_API __declspec(dllexport)
#else
#define MATHLIB_API __declspec(dllimport)
#endif

extern "C" {
    MATHLIB_API double CalculateCircleArea(double radius);
    MATHLIB_API double CalculateRectangleArea(double w, double h);
}

// mathlib.cpp
#include "mathlib.h"
#include <cmath>

MATHLIB_API double CalculateCircleArea(double radius) {
    return M_PI * radius * radius;
}

MATHLIB_API double CalculateRectangleArea(double w, double h) {
    return w * h;
}

4. Проецирование файлов

4.1. Memory-Mapped Files

4.2. Создание проекции в Windows

// 1. Открытие или создание файла
HANDLE hFile = CreateFile(
    L"data.bin",
    GENERIC_READ | GENERIC_WRITE,
    0, NULL, OPEN_ALWAYS,
    FILE_ATTRIBUTE_NORMAL, NULL
);

// 2. Создание объекта проекции
HANDLE hMapping = CreateFileMapping(
    hFile, NULL,
    PAGE_READWRITE,
    0, 1024 * 1024,  // Размер: 1 МБ
    L"MyMapping"
);

// 3. Проецирование в адресное пространство
LPVOID pView = MapViewOfFile(
    hMapping, FILE_MAP_ALL_ACCESS,
    0, 0, 0  // Весь файл
);

// 4. Использование
strcpy((char*)pView, "Hello, Memory Mapping!");

// 5. Освобождение
UnmapViewOfFile(pView);
CloseHandle(hMapping);
CloseHandle(hFile);

4.3. Проецирование в POSIX

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>

// 1. Открытие файла
int fd = open("data.bin", O_RDWR | O_CREAT, 0666);

// 2. Установка размера
ftruncate(fd, 1024 * 1024);

// 3. Проецирование
void* addr = mmap(
    NULL,           // Адрес (NULL = выбор системы)
    1024 * 1024,     // Размер
    PROT_READ | PROT_WRITE,  // Права доступа
    MAP_SHARED,     // Разделяемое отображение
    fd,             // Файловый дескриптор
    0               // Смещение
);

// 4. Использование
sprintf((char*)addr, "Hello, mmap!");

// 5. Освобождение
munmap(addr, 1024 * 1024);
close(fd);

5. Использование DLL

5.1. Неявное связывание

// Подключение библиотеки импорта
#pragma comment(lib, "mathlib.lib")

// Объявление функций
extern "C" __declspec(dllimport) 
double CalculateCircleArea(double radius);

// Использование
int main() {
    double area = CalculateCircleArea(5.0);
    printf("Area: %f\n", area);
    return 0;
}

5.2. Явное связывание

#include <windows.h>
#include <stdio.h>

typedef double (*CALC_CIRCLE_AREA)(double);

int main() {
    // Загрузка DLL
    HMODULE hModule = LoadLibrary(L"mathlib.dll");
    if (!hModule) {
        printf("Failed to load DLL\n");
        return 1;
    }
    
    // Получение адреса функции
    CALC_CIRCLE_AREA calcArea = (CALC_CIRCLE_AREA)
        GetProcAddress(hModule, "CalculateCircleArea");
    
    if (!calcArea) {
        printf("Failed to get function\n");
        FreeLibrary(hModule);
        return 1;
    }
    
    // Вызов
    double area = calcArea(5.0);
    printf("Area: %f\n", area);
    
    // Выгрузка
    FreeLibrary(hModule);
    return 0;
}

6. Обмен данными между процессами

6.1. Разделяемая память

Windows:

// Процесс 1 (создание)
HANDLE hMap = CreateFileMapping(
    INVALID_HANDLE_VALUE,  // Системный файл подкачки
    NULL, PAGE_READWRITE,
    0, 4096, L"SharedMemory"
);
void* pBuf = MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 4096);
strcpy((char*)pBuf, "Hello from Process 1");

// Процесс 2 (подключение)
HANDLE hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS, FALSE, L"SharedMemory");
void* pBuf = MapViewOfFile(hMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
printf("Received: %s\n", (char*)pBuf);

6.2. Разделяемая память в POSIX

// Процесс 1
int fd = shm_open("/myshm", O_CREAT | O_RDWR, 0666);
ftruncate(fd, 4096);
void* addr = mmap(NULL, 4096, PROT_READ | PROT_WRITE, 
                  MAP_SHARED, fd, 0);
sprintf((char*)addr, "Hello from Process 1");

// Процесс 2
int fd = shm_open("/myshm", O_RDWR, 0666);
void* addr = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
                  MAP_SHARED, fd, 0);
printf("Received: %s\n", (char*)addr);

6.3. Синхронизация доступа

Проблема: Несколько процессов одновременно изменяют данные.

Решение — именованные мьютексы:

// Windows
HANDLE hMutex = CreateMutex(NULL, FALSE, L"SharedMutex");
WaitForSingleObject(hMutex, INFINITE);
// Работа с разделяемой памятью
ReleaseMutex(hMutex);

// POSIX
sem_t* sem = sem_open("/mysem", O_CREAT, 0666, 1);
sem_wait(sem);
// Работа с разделяемой памятью
sem_post(sem);

7. Создание многозадачных комплексов

7.1. Архитектура многозадачного приложения

7.2. Паттерн "Мастер-Рабочие"

// Мастер-процесс
void MasterProcess() {
    // Создание разделяемой памяти
    HANDLE hShm = CreateFileMapping(...);
    void* pData = MapViewOfFile(...);
    
    // Создание рабочих процессов
    for (int i = 0; i < numWorkers; i++) {
        STARTUPINFO si = {sizeof(si)};
        PROCESS_INFORMATION pi;
        
        wchar_t cmdLine[256];
        swprintf(cmdLine, L"worker.exe %d", i);
        
        CreateProcess(NULL, cmdLine, ...);
    }
    
    // Распределение задач
    for (int i = 0; i < numTasks; i++) {
        // Запись задачи в разделяемую память
        // Сигнализация семафором
    }
    
    // Сбор результатов
    WaitForMultipleObjects(numWorkers, hWorkers, TRUE, INFINITE);
}

7.3. Паттерн "Производитель-Потребитель"

// Производитель
void Producer() {
    while (hasData) {
        sem_wait(&empty);   // Ждать свободное место
        sem_wait(&mutex);   // Захватить доступ
        
        buffer[in] = produce();
        in = (in + 1) % BUFFER_SIZE;
        
        sem_post(&mutex);   // Освободить доступ
        sem_post(&full);    // Уведомить о данных
    }
}

// Потребитель
void Consumer() {
    while (running) {
        sem_wait(&full);    // Ждать данные
        sem_wait(&mutex);   // Захватить доступ
        
        item = buffer[out];
        out = (out + 1) % BUFFER_SIZE;
        
        sem_post(&mutex);   // Освободить доступ
        sem_post(&empty);   // Уведомить о свободном месте
        
        consume(item);
    }
}

8. Перехват системных вызовов

8.1. Понятие hooking (перехвата)

8.2. IAT Hooking (Windows)

Import Address Table — таблица адресов импортируемых функций.

Пример IAT Hooking:

#include <windows.h>
#include <iostream>

// Тип оригинальной функции
typedef int (WINAPI* MessageBoxAPtr)(HWND, LPCSTR, LPCSTR, UINT);

MessageBoxAPtr OriginalMessageBoxA = nullptr;

// Наша функция-перехватчик
int WINAPI HookedMessageBoxA(HWND hWnd, LPCSTR lpText, 
                              LPCSTR lpCaption, UINT uType) {
    std::cout << "MessageBoxA called: " << lpText << std::endl;
    // Можем изменить параметры или заблокировать вызов
    return OriginalMessageBoxA(hWnd, "Hooked!", lpCaption, uType);
}

// Перехват IAT
void HookIAT(const char* moduleName, const char* funcName, void* newFunc) {
    HMODULE hModule = GetModuleHandleA(NULL);
    IMAGE_DOS_HEADER* dosHeader = (IMAGE_DOS_HEADER*)hModule;
    IMAGE_NT_HEADERS* ntHeaders = (IMAGE_NT_HEADERS*)((BYTE*)hModule + 
                                                        dosHeader->e_lfanew);
    
    IMAGE_IMPORT_DESCRIPTOR* importDesc = (IMAGE_IMPORT_DESCRIPTOR*)(
        (BYTE*)hModule + ntHeaders->OptionalHeader.DataDirectory[
            IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
    
    while (importDesc->Name) {
        const char* dllName = (const char*)((BYTE*)hModule + importDesc->Name);
        
        if (_stricmp(dllName, moduleName) == 0) {
            IMAGE_THUNK_DATA* thunk = (IMAGE_THUNK_DATA*)(
                (BYTE*)hModule + importDesc->FirstThunk);

            while (thunk->u1.Function) {
                FARPROC* funcPtr = (FARPROC*)&thunk->u1.Function;
                
                if (*funcPtr == GetProcAddress(
                        GetModuleHandleA(moduleName), funcName)) {
                    
                    DWORD oldProtect;
                    VirtualProtect(funcPtr, sizeof(void*), 
                                   PAGE_EXECUTE_READWRITE, &oldProtect);
                    
                    OriginalMessageBoxA = (MessageBoxAPtr)*funcPtr;
                    *funcPtr = (FARPROC)newFunc;
                    
                    VirtualProtect(funcPtr, sizeof(void*), 
                                   oldProtect, &oldProtect);
                }
                thunk++;
            }
        }
        importDesc++;
    }
}

8.3. LD_PRELOAD (Linux)

LD_PRELOAD — переменная окружения для загрузки библиотек до других.

// hook.c
#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>

static void* (*real_malloc)(size_t) = NULL;

void* malloc(size_t size) {
    if (!real_malloc) {
        real_malloc = dlsym(RTLD_NEXT, "malloc");
    }
    
    printf("malloc(%zu) called\n", size);
    return real_malloc(size);
}

void free(void* ptr) {
    static void (*real_free)(void*) = NULL;
    if (!real_free) {
        real_free = dlsym(RTLD_NEXT, "free");
    }
    
    printf("free(%p) called\n", ptr);
    real_free(ptr);
}

gcc -shared -fPIC -o hook.so hook.c -ldl
LD_PRELOAD=./hook.so ./program

8.4. ptrace (Linux)

ptrace — системный вызов для отладки и трассировки процессов.

#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/user.h>

int main() {
    pid_t child = fork();
    
    if (child == 0) {
        // Дочерний процесс: разрешаем трассировку
        ptrace(PTRACE_TRACEME, 0, NULL, NULL);
        execl("./target", "target", NULL);
    } else {
        // Родительский процесс: трассируем
        int status;
        waitpid(child, &status, 0);

        while (WIFSTOPPED(status)) {
            struct user_regs_struct regs;
            ptrace(PTRACE_GETREGS, child, NULL, &regs);
            
            printf("Syscall: %lld\n", regs.orig_rax);
            
            // Продолжить до следующего syscall
            ptrace(PTRACE_SYSCALL, child, NULL, NULL);
            waitpid(child, &status, 0);
        }
    }
    
    return 0;
}

8.5. Microsoft Detours

Detours — библиотека Microsoft для hooking на уровне кода.

#include <detours.h>
#include <windows.h>

static int (WINAPI* TrueMessageBoxA)(HWND, LPCSTR, LPCSTR, UINT) = MessageBoxA;

int WINAPI HookedMessageBoxA(HWND hWnd, LPCSTR lpText, 
                              LPCSTR lpCaption, UINT uType) {
    return TrueMessageBoxA(hWnd, "Detoured!", lpCaption, uType);
}

int main() {
    // Установка hook
    DetourTransactionBegin();
    DetourUpdateThread(GetCurrentThread());
    DetourAttach(&(PVOID&)TrueMessageBoxA, HookedMessageBoxA);
    DetourTransactionCommit();
    
    MessageBoxA(NULL, "Test", "Test", MB_OK);
    
    // Снятие hook
    DetourTransactionBegin();
    DetourUpdateThread(GetCurrentThread());
    DetourDetach(&(PVOID&)TrueMessageBoxA, HookedMessageBoxA);
    DetourTransactionCommit();
    
    return 0;
}

8.6. eBPF (Linux)

eBPF (Extended Berkeley Packet Filter) — технология выполнения песочницы программ в ядре Linux без необходимости написания модулей ядра.

Архитектура eBPF:

Ключевые компоненты:

• Verifier — статический анализатор, проверяющий безопасность программы (отсутствие бесконечных циклов, доступ только к разрешённой памяти, ограниченное число инструкций)
• JIT-компиляция — преобразование BPF-байткода в нативный машинный код для максимальной производительности
• BPF Maps — структуры данных для обмена между ядром и пользовательским пространством (hash, array, ring buffer, per-CPU)
• Helper functions — набор разрешённых функций ядра, которые eBPF-программа может вызывать (bpf_get_current_pid_tgid, bpf_probe_read, bpf_trace_printk и др.)

Типы eBPF-программ:

Пример: трассировка open() с помощью bpftrace (однострочник):

sudo bpftrace -e 'tracepoint:syscalls:sys_enter_openat { printf("%s: %s\n", comm, str(args->filename)); }'

Пример: BPF-программа с BCC (Python + BPF C):

from bcc import BPF

bpf_text = """
#include <uapi/linux/ptrace.h>

struct data_t {
    u32 pid;
    char comm[16];
    char fname[256];
};

BPF_PERF_OUTPUT(events);

int trace_open(struct pt_regs *ctx, const char __user *filename) {
    struct data_t data = {};
    u32 pid = bpf_get_current_pid_tgid() >> 32;

    data.pid = pid;
    bpf_get_current_comm(&data.comm, sizeof(data.comm));
    bpf_probe_read_user_str(&data.fname, sizeof(data.fname), filename);

    events.perf_submit(ctx, &data, sizeof(data));
    return 0;
}
"""

b = BPF(text=bpf_text)
b.attach_kprobe(event="do_sys_openat2", fn_name="trace_open")

def print_event(cpu, data, size):
    event = b["events"].event(data)
    print(f"{event.comm.decode()} [{event.pid}] {event.fname.decode()}")

b["events"].open_perf_buffer(print_event)

while True:
    b.perf_buffer_poll()

Инструменты на базе eBPF:

Пример: tracing open() syscalls (libbpf, eBPF C):

#include <vmlinux.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>

struct event {
    u32 pid;
    char comm[16];
    char fname[256];
};

struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 1 << 24);
} events SEC(".maps");

SEC("tracepoint/syscalls/sys_enter_openat")
int trace_openat(struct trace_event_raw_sys_enter* ctx) {
    struct event* e;

    e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
    if (!e) return 0;

    e->pid = bpf_get_current_pid_tgid() >> 32;
    bpf_get_current_comm(&e->comm, sizeof(e->comm));
    bpf_probe_read_user_str(&e->fname, sizeof(e->fname),
                             (const char*)ctx->args[1]);

    bpf_ringbuf_submit(e, 0);
    return 0;
}

char LICENSE[] SEC("license") = "GPL";

Сравнение методов мониторинга/перехвата:

8.7. Сравнение методов hooking

Рекомендации:

• Отладка/мониторинг: LD_PRELOAD, ptrace, eBPF
• Модификация ПО: Detours, IAT Hooking
• Безопасность: eBPF, kernel modules

Резюме

Ключевые моменты лекции:

1. DLL — динамически подключаемые библиотеки
2. Экспорт/Импорт — механизмы использования DLL
3. Проецирование файлов — эффективная работа с памятью
4. Разделяемая память — IPC через общую память
5. Синхронизация — защита разделяемых данных
6. Многозадачность — паттерны распределения работы
7. Hooking — перехват системных вызовов

Вопросы для самопроверки

1. Чем отличается неявное связывание от явного?
2. Какие функции выполняет DllMain?
3. Что такое проецирование файла?
4. Как организовать обмен данными между процессами?
5. Какие паттерны многозадачности существуют?
6. Как синхронизировать доступ к разделяемой памяти?
7. Что такое IAT Hooking?
8. Как работает LD_PRELOAD?
9. Что такое eBPF и для чего он используется?

Практические задания

Самостоятельная работа (6 часов):

1. Создать простую DLL с экспортируемыми функциями
2. Написать программу с явной загрузкой DLL
3. Организовать разделяемую память между процессами
4. Исследовать LD_PRELOAD для перехвата функций

Рекомендуемая литература

Основная:

1. Таненбаум, Э. Современные операционные системы. — 4-е изд. — СПб.: Питер, 2021.
2. Kerrisk, M. The Linux Programming Interface. — No Starch Press, 2010.

Дополнительная:

3. MSDN: Dynamic-Link Libraries, File Mapping, Detours
4. man pages: dlopen(3), mmap(2), shm_overview(7), ptrace(2)
5. eBPF Documentation: https://ebpf.io/
6. Microsoft Detours: https://github.com/microsoft/Detours